// @ts-ignore
/* eslint-disable */
import request from '@/utils/request';

/** 收支审核 POST /fds/StAccount/accRecordCheckPur */
export async function accRecordCheckPurUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.accRecordCheckPurUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/StAccount/accRecordCheckPur', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 收支反审核 POST /fds/StAccount/accRecordUnCheckPur */
export async function accRecordUnCheckPurUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.accRecordUnCheckPurUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/StAccount/accRecordUnCheckPur', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 新增收支 POST /fds/StAccount/addAccRecord */
export async function addAccRecordUsingPOST(body: API.Pinyin_65, options?: { [key: string]: any }) {
  return request<API.Pinyin_105>('/fds/StAccount/addAccRecord', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 新增债务账户 POST /fds/StAccount/addDebt */
export async function addDebtUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.addDebtUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.Pinyin_18>('/fds/StAccount/addDebt', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 新增债务 POST /fds/StAccount/addDebtRecord */
export async function addDebtRecordUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.addDebtRecordUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.Pinyin_17>('/fds/StAccount/addDebtRecord', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 新增押金 POST /fds/StAccount/addDeposit */
export async function addEmployeesUsingPOST1(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.addEmployeesUsingPOST1Params,
  options?: { [key: string]: any },
) {
  return request<API.Pinyin_64>('/fds/StAccount/addDeposit', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 批量导入押金 POST /fds/StAccount/addDepositBatch */
export async function addDepositBatchUsingPOST(
  body: API.Pinyin_64[],
  options?: { [key: string]: any },
) {
  return request<boolean>('/fds/StAccount/addDepositBatch', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 新增入股 POST /fds/StAccount/addInStock */
export async function addInStockUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.addInStockUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.Pinyin_80>('/fds/StAccount/addInStock', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 商品销售/运营商业务销售 POST /fds/StAccount/addSales */
export async function addSalesUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.addSalesUsingPOSTParams,
  body: API.Pinyin_100,
  options?: { [key: string]: any },
) {
  return request<API.Pinyin_102>('/fds/StAccount/addSales', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    params: {
      ...params,
    },
    data: body,
    ...(options || {}),
  });
}

/** 新增分摊 POST /fds/StAccount/addShare */
export async function addShareUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.addShareUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.Pinyin_103>('/fds/StAccount/addShare', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 新增账户 POST /fds/StAccount/addStAccount */
export async function addStAccountUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.addStAccountUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.Pinyin_23>('/fds/StAccount/addStAccount', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 新增股东 POST /fds/StAccount/addStock */
export async function addStockUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.addStockUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.Pinyin_81>('/fds/StAccount/addStock', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 追加销售 POST /fds/StAccount/appendSales */
export async function appendSalesUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.appendSalesUsingPOSTParams,
  body: API.Pinyin_94,
  options?: { [key: string]: any },
) {
  return request<API.Pinyin_102>('/fds/StAccount/appendSales', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    params: {
      ...params,
    },
    data: body,
    ...(options || {}),
  });
}

/** 债务审核 POST /fds/StAccount/checkDebtRecord */
export async function checkDebtRecordUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.checkDebtRecordUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/StAccount/checkDebtRecord', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 审核销售订单 POST /fds/StAccount/checkSales */
export async function checkSalesUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.checkSalesUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<boolean>('/fds/StAccount/checkSales', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 转账审核 POST /fds/StAccount/checkTransferStAcc */
export async function checkerTransferStAccUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.checkerTransferStAccUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/StAccount/checkTransferStAcc', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取欠债账户财务统计列表 GET /fds/StAccount/debtFinStatistics */
export async function debtFinStatisticsUsingGET(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.debtFinStatisticsUsingGETParams,
  options?: { [key: string]: any },
) {
  return request<API.PageResult15>('/fds/StAccount/debtFinStatistics', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 押金审核 POST /fds/StAccount/depositCheckPur */
export async function depositCheckPurUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.depositCheckPurUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/StAccount/depositCheckPur', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 押金反审核 POST /fds/StAccount/depositUnCheckPur */
export async function depositUnCheckPurUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.depositUnCheckPurUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/StAccount/depositUnCheckPur', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 导出取收支列表 POST /fds/StAccount/exportAccRecordList */
export async function exportAccRecordListUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.exportAccRecordListUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/StAccount/exportAccRecordList', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 导出欠债账户财务统计列表 POST /fds/StAccount/exportDebtFinStatistics */
export async function exportDebtFinStatisticsUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.exportDebtFinStatisticsUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/StAccount/exportDebtFinStatistics', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 导出债务账户列表 POST /fds/StAccount/exportDebtList */
export async function exportLosDetailUsingPOST4(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.exportLosDetailUsingPOST4Params,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/StAccount/exportDebtList', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 导出押金记录表 POST /fds/StAccount/exportDepositList */
export async function exportDepositListUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.exportDepositListUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/StAccount/exportDepositList', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 导出业务销售订单提成详情列表 POST /fds/StAccount/exportEmpOpSalesDetailList */
export async function exportEmpOpSalesDetailListUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.exportEmpOpSalesDetailListUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/StAccount/exportEmpOpSalesDetailList', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 导出商品销售订单提成详情列表 POST /fds/StAccount/exportEmpSalesDetailList */
export async function exportEmpSalesDetailListUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.exportEmpSalesDetailListUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/StAccount/exportEmpSalesDetailList', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 导出商品列表 POST /fds/StAccount/exportGoodList */
export async function exportGoodListUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.exportGoodListUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/StAccount/exportGoodList', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 导出销售记录列表 POST /fds/StAccount/exportMyOrderList */
export async function exportMyOrderListUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.exportMyOrderListUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/StAccount/exportMyOrderList', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 导出分摊列表 POST /fds/StAccount/exportShareList */
export async function exportShareListUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.exportShareListUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/StAccount/exportShareList', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 导出前台账户流水列表 POST /fds/StAccount/exportStAcclogList */
export async function exportStAcclogListUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.exportStAcclogListUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/StAccount/exportStAcclogList', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 导出前台账户列表 POST /fds/StAccount/exportStAccountList */
export async function exportStAccountListUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.exportStAccountListUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/StAccount/exportStAccountList', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 导出前台财务统计列表 POST /fds/StAccount/exportStFinSta */
export async function exportStFinStaUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.exportStFinStaUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/StAccount/exportStFinSta', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 导出股东表 POST /fds/StAccount/exportStockList */
export async function exportStockListUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.exportStockListUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/StAccount/exportStockList', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 导出股份变动记录表 POST /fds/StAccount/exportStockRecordList */
export async function exportStockRecordListUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.exportStockRecordListUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/StAccount/exportStockRecordList', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取账户财务统计列表 GET /fds/StAccount/FinancialStatistics */
export async function financialStatisticsUsingGET(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.financialStatisticsUsingGETParams,
  options?: { [key: string]: any },
) {
  return request<API.PageResult18>('/fds/StAccount/FinancialStatistics', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 查询收支 GET /fds/StAccount/getAccRecord */
export async function getAccRecordUsingGET(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getAccRecordUsingGETParams,
  options?: { [key: string]: any },
) {
  return request<API.AccRecordDto>('/fds/StAccount/getAccRecord', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取收支列表 GET /fds/StAccount/getAccRecordList */
export async function getAccRecordListUsingGET(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getAccRecordListUsingGETParams,
  options?: { [key: string]: any },
) {
  return request<API.PageResultAccRecordDto_>('/fds/StAccount/getAccRecordList', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 查询债务账户 GET /fds/StAccount/getDebt */
export async function getDebtUsingGET(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getDebtUsingGETParams,
  options?: { [key: string]: any },
) {
  return request<API.Pinyin_18>('/fds/StAccount/getDebt', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取债务账户列表 GET /fds/StAccount/getDebtList */
export async function getDebtListUsingGET(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getDebtListUsingGETParams,
  options?: { [key: string]: any },
) {
  return request<API.PageResult13>('/fds/StAccount/getDebtList', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 查询债务记录 POST /fds/StAccount/getDebtRecord */
export async function getDebtRecordUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getDebtRecordUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.Pinyin_03>('/fds/StAccount/getDebtRecord', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取押金详情 GET /fds/StAccount/getDeposit */
export async function getDepositUsingGET(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getDepositUsingGETParams,
  options?: { [key: string]: any },
) {
  return request<API.DepositDto>('/fds/StAccount/getDeposit', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取押金记录表 GET /fds/StAccount/getDepositList */
export async function getDepositListUsingGET(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getDepositListUsingGETParams,
  options?: { [key: string]: any },
) {
  return request<API.PageResultDepositDto_>('/fds/StAccount/getDepositList', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取业务销售订单提成详情列表 POST /fds/StAccount/getEmpOpSalesDetailList */
export async function getEmpOpSalesDetailListUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getEmpOpSalesDetailListUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.PageResult20>('/fds/StAccount/getEmpOpSalesDetailList', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取商品销售订单提成详情列表 POST /fds/StAccount/getEmpSalesDetailList */
export async function getEmpSalesDetailListUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getEmpSalesDetailListUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.PageResult21>('/fds/StAccount/getEmpSalesDetailList', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取商品列表 POST /fds/StAccount/getGoodList */
export async function getGoodListUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getGoodListUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.PageResultSalDetailDto_>('/fds/StAccount/getGoodList', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 通过串码1模糊查询库存信息 POST /fds/StAccount/getInventoryListByPhoneCde */
export async function getInventoryListByPhoneCdeUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getInventoryListByPhoneCdeUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.PageResult31>('/fds/StAccount/getInventoryListByPhoneCde', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取销售记录列表 POST /fds/StAccount/getMyOrderList */
export async function getMyOrderListUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getMyOrderListUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.PageResultSalesDto_>('/fds/StAccount/getMyOrderList', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取业务列表 GET /fds/StAccount/getOpBusinessList */
export async function getOpBusinessListUsingGET(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getOpBusinessListUsingGETParams,
  options?: { [key: string]: any },
) {
  return request<API.PageResultOpBusinessDto_>('/fds/StAccount/getOpBusinessList', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取工号列表 GET /fds/StAccount/getOpEmpNoList */
export async function getOpEmpNoListUsingGET(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getOpEmpNoListUsingGETParams,
  options?: { [key: string]: any },
) {
  return request<API.PageResultOpEmpNoDto_>('/fds/StAccount/getOpEmpNoList', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 通过Id获取已销售的业务 GET /fds/StAccount/getSaleOutBusiness */
export async function getSaleOutBusinessUsingGET(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getSaleOutBusinessUsingGETParams,
  options?: { [key: string]: any },
) {
  return request<API.OpSalesDetailDto>('/fds/StAccount/getSaleOutBusiness', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取已销售的业务列表 GET /fds/StAccount/getSaleOutBusinessList */
export async function getSaleOutBusinessListUsingGET(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getSaleOutBusinessListUsingGETParams,
  options?: { [key: string]: any },
) {
  return request<API.PageResultOpSalesDetailDto_>('/fds/StAccount/getSaleOutBusinessList', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 通过串码获取已销售的商品 GET /fds/StAccount/getSaleOutGoods */
export async function getSaleOutGoodsUsingGET(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getSaleOutGoodsUsingGETParams,
  options?: { [key: string]: any },
) {
  return request<API.Pinyin_58>('/fds/StAccount/getSaleOutGoods', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取已销售的商品列表 GET /fds/StAccount/getSaleOutGoodsList */
export async function getSaleOutGoodsListUsingGET(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getSaleOutGoodsListUsingGETParams,
  options?: { [key: string]: any },
) {
  return request<API.PageResult32>('/fds/StAccount/getSaleOutGoodsList', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取销售订单信息 GET /fds/StAccount/getSales */
export async function getSalesUsingGET(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getSalesUsingGETParams,
  options?: { [key: string]: any },
) {
  return request<API.SalesDto>('/fds/StAccount/getSales', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取店面销售记录详细列表 POST /fds/StAccount/getSalesStoreDetailList */
export async function getSalesStoreDetailListUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getSalesStoreDetailListUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.PageResultSalDetailListDto_>('/fds/StAccount/getSalesStoreDetailList', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取付款信息列表 GET /fds/StAccount/getSalPayList */
export async function getSalPayUsingGET(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getSalPayUsingGETParams,
  options?: { [key: string]: any },
) {
  return request<API.PageResultSalPayDto_>('/fds/StAccount/getSalPayList', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 查询分摊 GET /fds/StAccount/getShare */
export async function getShareUsingGET(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getShareUsingGETParams,
  options?: { [key: string]: any },
) {
  return request<API.ShareDto>('/fds/StAccount/getShare', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取分摊列表 GET /fds/StAccount/getShareList */
export async function getShareListUsingGET(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getShareListUsingGETParams,
  options?: { [key: string]: any },
) {
  return request<API.PageResultShareDto_>('/fds/StAccount/getShareList', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取前台账户流水详情 GET /fds/StAccount/getStAcclog */
export async function getStAcclogUsingGET(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getStAcclogUsingGETParams,
  options?: { [key: string]: any },
) {
  return request<API.Pinyin_05>('/fds/StAccount/getStAcclog', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取前台账户流水列表 GET /fds/StAccount/getStAcclogList */
export async function getStAcclogListUsingGET(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getStAcclogListUsingGETParams,
  options?: { [key: string]: any },
) {
  return request<API.PageResult16>('/fds/StAccount/getStAcclogList', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 查询账户 GET /fds/StAccount/getStAccount */
export async function getStAccountUsingGET(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getStAccountUsingGETParams,
  options?: { [key: string]: any },
) {
  return request<API.Pinyin_23>('/fds/StAccount/getStAccount', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** (下拉框使用)通过账户类型获取账户列表 GET /fds/StAccount/getStAccountList */
export async function getStAccountListByTypeUsingGET(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getStAccountListByTypeUsingGETParams,
  options?: { [key: string]: any },
) {
  return request<API.PageResult17>('/fds/StAccount/getStAccountList', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取前台账户列表 GET /fds/StAccount/getStAccountPage */
export async function getStAccountListUsingGET(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getStAccountListUsingGETParams,
  options?: { [key: string]: any },
) {
  return request<API.PageResultStAccountDto_>('/fds/StAccount/getStAccountPage', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 查询股东 GET /fds/StAccount/getStock */
export async function getStockUsingGET(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getStockUsingGETParams,
  options?: { [key: string]: any },
) {
  return request<API.Pinyin_81>('/fds/StAccount/getStock', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取股东表 GET /fds/StAccount/getStockList */
export async function getStockListUsingGET(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getStockListUsingGETParams,
  options?: { [key: string]: any },
) {
  return request<API.PageResultStockDto_>('/fds/StAccount/getStockList', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 查询股份变动记录 GET /fds/StAccount/getStockRecord */
export async function getStockRecordUsingGET(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getStockRecordUsingGETParams,
  options?: { [key: string]: any },
) {
  return request<API.StockRecordDto>('/fds/StAccount/getStockRecord', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取股份变动记录表 GET /fds/StAccount/getStockRecordList */
export async function getStockRecordListUsingGET(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getStockRecordListUsingGETParams,
  options?: { [key: string]: any },
) {
  return request<API.PageResultStockRecordDto_>('/fds/StAccount/getStockRecordList', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取门店支付方式列表 GET /fds/StAccount/getStorePayMeth */
export async function getStorePayMethUsingGET(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getStorePayMethUsingGETParams,
  options?: { [key: string]: any },
) {
  return request<API.PageResult43>('/fds/StAccount/getStorePayMeth', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 查询转账信息 POST /fds/StAccount/getTransferStAcc */
export async function getTransferStAccUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.getTransferStAccUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.Pinyin_06>('/fds/StAccount/getTransferStAcc', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 订单速查 GET /fds/StAccount/orderQuickCheck */
export async function orderQuickCheckUsingGET(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.orderQuickCheckUsingGETParams,
  options?: { [key: string]: any },
) {
  return request<string>('/fds/StAccount/orderQuickCheck', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 支付 POST /fds/StAccount/payment */
export async function paymentUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.paymentUsingPOSTParams,
  body: API.SalPayParam[],
  options?: { [key: string]: any },
) {
  return request<boolean>('/fds/StAccount/payment', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    params: {
      ...params,
    },
    data: body,
    ...(options || {}),
  });
}

/** 归还押金 POST /fds/StAccount/repay */
export async function repayUsingPOST(body: API.Pinyin_60, options?: { [key: string]: any }) {
  return request<API.Pinyin_64>('/fds/StAccount/repay', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 撤销收支订单 POST /fds/StAccount/revokeAccRecord */
export async function revokeAccRecordUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.revokeAccRecordUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<boolean>('/fds/StAccount/revokeAccRecord', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 撤销债务 POST /fds/StAccount/revokeDebtRecord */
export async function revokeDebtRecordUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.revokeDebtRecordUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<boolean>('/fds/StAccount/revokeDebtRecord', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 撤销押金 POST /fds/StAccount/revokeDeposit */
export async function revokeDepositUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.revokeDepositUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<boolean>('/fds/StAccount/revokeDeposit', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 撤销销售订单 POST /fds/StAccount/revokeSales */
export async function revokeSalesUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.revokeSalesUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<boolean>('/fds/StAccount/revokeSales', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 撤销分摊 POST /fds/StAccount/revokeShare */
export async function revokeShareUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.revokeShareUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<boolean>('/fds/StAccount/revokeShare', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 撤销前台账户流水订单 POST /fds/StAccount/revokeStAcclog */
export async function revokeStAcclogUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.revokeStAcclogUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<boolean>('/fds/StAccount/revokeStAcclog', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 撤销股份变动记录 POST /fds/StAccount/revokeStockRecord */
export async function revokeStockRecordUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.revokeStockRecordUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<boolean>('/fds/StAccount/revokeStockRecord', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 转账撤销 POST /fds/StAccount/revokeTransferStAcc */
export async function revokeTransferStAccUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.revokeTransferStAccUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<boolean>('/fds/StAccount/revokeTransferStAcc', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 分摊审核 POST /fds/StAccount/shareCheckPur */
export async function shareCheckPurUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.shareCheckPurUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/StAccount/shareCheckPur', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 分摊反审核 POST /fds/StAccount/shareUnCheckPur */
export async function shareUnCheckPurUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.shareUnCheckPurUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/StAccount/shareUnCheckPur', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 前台账户流水审核 POST /fds/StAccount/StAcclogCheckPur */
export async function stAcclogCheckPurUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.stAcclogCheckPurUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/StAccount/StAcclogCheckPur', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 前台账户流水反审核 POST /fds/StAccount/StAcclogUnCheckPur */
export async function stAcclogUnCheckPurUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.stAcclogUnCheckPurUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/StAccount/StAcclogUnCheckPur', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 股份变动记录审核 POST /fds/StAccount/StockRecordCheckPur */
export async function stockRecordCheckPurUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.stockRecordCheckPurUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/StAccount/StockRecordCheckPur', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 股份变动记录反审核 POST /fds/StAccount/StockRecordUnCheckPur */
export async function stockRecordUnCheckPurUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.stockRecordUnCheckPurUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/StAccount/StockRecordUnCheckPur', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 新增转账 POST /fds/StAccount/transferStAcc */
export async function transferStAccUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.transferStAccUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.Pinyin_25>('/fds/StAccount/transferStAcc', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 债务反审核 POST /fds/StAccount/unCheckDebtRecord */
export async function unCheckDebtRecordUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.unCheckDebtRecordUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/StAccount/unCheckDebtRecord', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 反审核销售订单 POST /fds/StAccount/unCheckSales */
export async function unCheckSalesUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.unCheckSalesUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<boolean>('/fds/StAccount/unCheckSales', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 转账反审核 POST /fds/StAccount/unCheckTransferStAcc */
export async function unCheckTransferStAccUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.unCheckTransferStAccUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<any>('/fds/StAccount/unCheckTransferStAcc', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 修改收支 POST /fds/StAccount/updateAccRecord */
export async function updateAccRecordUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.updateAccRecordUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.Pinyin_105>('/fds/StAccount/updateAccRecord', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 修改债务账户 POST /fds/StAccount/updateDebt */
export async function updateDebtUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.updateDebtUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.Pinyin_18>('/fds/StAccount/updateDebt', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 修改债务记录 POST /fds/StAccount/updateDebtRecord */
export async function updateDebtRecordUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.updateDebtRecordUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.Pinyin_17>('/fds/StAccount/updateDebtRecord', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 修改押金 POST /fds/StAccount/updateDeposit */
export async function updateDepositUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.updateDepositUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.Pinyin_64>('/fds/StAccount/updateDeposit', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 编辑订单 POST /fds/StAccount/updateSales */
export async function updateSalesUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.updateSalesUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.Pinyin_102>('/fds/StAccount/updateSales', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 修改分摊 POST /fds/StAccount/updateShare */
export async function updateShareUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.updateShareUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.Pinyin_103>('/fds/StAccount/updateShare', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 修改账户 POST /fds/StAccount/updateStAccount */
export async function updateStAccountUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.updateStAccountUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.Pinyin_23>('/fds/StAccount/updateStAccount', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 修改股东 POST /fds/StAccount/updateStock */
export async function updateStockUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.updateStockUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.Pinyin_81>('/fds/StAccount/updateStock', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 修改股份变动记录 POST /fds/StAccount/updateStockRecord */
export async function updateStockRecordUsingPOST(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.updateStockRecordUsingPOSTParams,
  options?: { [key: string]: any },
) {
  return request<API.Pinyin_80>('/fds/StAccount/updateStockRecord', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}
